﻿using DevExpress.XtraEditors;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using MesProjectWinform.Public.Common;
using MesProjectWinform.BasicData.Entity;
using System.IO;

namespace MesProjectWinform.BasicData.基础实现.chanpin
{
    public partial class pinup : DevExpress.XtraEditors.XtraForm
    {
        // 用于存储无人机相关的群组数据
        private Dictionary<string, List<string>> droneGroups = new Dictionary<string, List<string>>();
        // 用于存储工艺路线数据
        private List<string> processRoutes = new List<string>();
        // 用于存储单位数据
        private List<string> units = new List<string>();
        // 标记当前是新增还是编辑模式
        private bool isEditMode = false;
        // 产品ID，编辑模式时使用
        private long productId = 0;
        // 原始产品数据，编辑模式时使用
        private ProductItemModel originalProduct = null;
        // 序号存储文件路径
        private readonly string sequenceFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ProductSequence.txt");
        // 日期格式化字符串
        private readonly string dateFormat = "yyMMdd";

        public pinup()
        {
            InitializeComponent();

            // 初始化控件
            InitializeControls();

            // 初始化无人机相关群组数据
            InitializeDroneGroups();

            // 初始化工艺路线数据
            InitializeProcessRoutes();
            
            // 初始化单位数据
            InitializeUnits();
            
            // 设置窗体加载事件
            this.Load += Pinup_Load;
            
            // 设置编码文本框为只读
            if (textEdit1 != null)
                textEdit1.Properties.ReadOnly = true;
                
            // 新增模式下生成自动编号
            if (!isEditMode)
            {
                GenerateAutoIncrementCode();
            }
            
            // 设置窗体居中显示
            this.StartPosition = FormStartPosition.CenterScreen;
        }
        
        /// <summary>
        /// 编辑模式的构造函数
        /// </summary>
        /// <param name="id">产品ID</param>
        public pinup(long id) : this()
        {
            this.productId = id;
            this.isEditMode = true;
        }
        
        /// <summary>
        /// 窗体加载事件
        /// </summary>
        private void Pinup_Load(object sender, EventArgs e)
        {
            // 如果是编辑模式，加载产品数据
            if (isEditMode && productId > 0)
            {
                LoadProductData();
            }
        }
        
        /// <summary>
        /// 加载产品数据
        /// </summary>
        private async void LoadProductData()
        {
            try
            {
                this.Text = "修改产品物料";
                
                // 构建API请求URL
                string url = $"api/ProductItem/GetProductItemById?id={productId}";
                
                // 临时保存原始BaseUrl
                string originalBaseUrl = Properties.Settings.Default.BaseUrl;
                string result = string.Empty;
                
                try
                {
                    // 临时修改BaseUrl为与chanpin.cs中相同的API地址
                    Properties.Settings.Default.BaseUrl = "http://47.110.243.157:5052/";
                    
                    // 发送请求获取数据
                    result = await HttpClientHelper.RequestUrl(RequestType.Get, url, string.Empty);
                }
                finally
                {
                    // 恢复原始BaseUrl
                    Properties.Settings.Default.BaseUrl = originalBaseUrl;
                }
                
                if (string.IsNullOrEmpty(result))
                {
                    XtraMessageBox.Show("获取产品数据失败，请稍后重试", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }
                
                try
                {
                    // 解析返回的JSON数据
                    Newtonsoft.Json.Linq.JObject jsonObj = Newtonsoft.Json.Linq.JObject.Parse(result);
                    
                    // 检查返回码
                    if (jsonObj["Code"]?.ToString() != "200")
                    {
                        XtraMessageBox.Show(jsonObj["Message"]?.ToString() ?? "请求失败", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        return;
                    }
                    
                    // 从Data字段获取产品数据
                    if (jsonObj["Data"] != null)
                    {
                        originalProduct = jsonObj["Data"].ToObject<ProductItemModel>();
                        
                        if (originalProduct != null)
                        {
                            // 填充表单数据
                            textEdit1.Text = originalProduct.Productitemcode; // 产品编码
                            textEdit2.Text = originalProduct.Productitemname; // 产品名称
                            
                            // 规格型号
                            textEdit3.Text = originalProduct.Productitemspecification;
                            
                            // 设置单位
                            int unitIndex = comboBox1.Items.IndexOf(originalProduct.Productitemunit);
                            if (unitIndex >= 0)
                            {
                                comboBox1.SelectedIndex = unitIndex;
                            }
                            
                            // 预警值
                            SpinEdit warningValueSpinEdit = this.Controls.Find("warningValueSpinEdit", true).FirstOrDefault() as SpinEdit;
                            if (warningValueSpinEdit != null)
                            {
                                warningValueSpinEdit.EditValue = originalProduct.Productitemwarningvalue;
                            }
                            
                            // 设置产品类型
                            if (originalProduct.Producttype > 0 && originalProduct.Producttype <= 4)
                            {
                                comboBox3.SelectedIndex = originalProduct.Producttype - 1;
                                
                                // 触发类型变更事件，填充群组下拉框
                                comboBox3_SelectedIndexChanged(comboBox3, EventArgs.Empty);
                                
                                // 设置群组
                                if (!string.IsNullOrEmpty(originalProduct.Materialgroupid))
                                {
                                    int groupIndex = comboBox2.Items.IndexOf(originalProduct.Materialgroupid);
                                    if (groupIndex >= 0)
                                    {
                                        comboBox2.SelectedIndex = groupIndex;
                                    }
                                    else
                                    {
                                        // 如果在列表中找不到，但有值，则直接添加
                                        if (!string.IsNullOrEmpty(originalProduct.Materialgroupid) && 
                                            originalProduct.Materialgroupid != "-")
                                        {
                                            comboBox2.Items.Add(originalProduct.Materialgroupid);
                                            comboBox2.SelectedIndex = comboBox2.Items.Count - 1;
                                        }
                                    }
                                }
                            }
                            
                            // 设置工艺路线
                            ComboBoxEdit processRouteCombo = this.Controls.Find("processRouteCombo", true).FirstOrDefault() as ComboBoxEdit;
                            if (processRouteCombo != null && processRouteCombo.Visible && !string.IsNullOrEmpty(originalProduct.Processrouteid))
                            {
                                int routeIndex = -1;
                                for (int i = 0; i < processRouteCombo.Properties.Items.Count; i++)
                                {
                                    if (processRouteCombo.Properties.Items[i].ToString() == originalProduct.Processrouteid)
                                    {
                                        routeIndex = i;
                                        break;
                                    }
                                }
                                
                                if (routeIndex >= 0)
                                {
                                    processRouteCombo.SelectedIndex = routeIndex;
                                }
                            }
                            
                            // 设置描述信息
                            if (this.Controls["memoEdit1"] is MemoEdit descEdit)
                            {
                                descEdit.Text = originalProduct.Productitemdescribe;
                            }
                            
                            XtraMessageBox.Show("数据加载成功", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                        else
                        {
                            XtraMessageBox.Show("产品数据转换失败", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                    else
                    {
                        XtraMessageBox.Show("未找到相关产品数据", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                }
                catch (Exception ex)
                {
                    XtraMessageBox.Show($"解析数据异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"加载数据异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 初始化控件
        /// </summary>
        private void InitializeControls()
        {
            try
            {
                // 1. 设置预警值的SpinEdit控件（可点击增加数字）
                SpinEdit warningValueSpinEdit = new SpinEdit();
                warningValueSpinEdit.Name = "warningValueSpinEdit";
                warningValueSpinEdit.Properties.Increment = 1;
                warningValueSpinEdit.Properties.MinValue = 0;
                warningValueSpinEdit.Properties.MaxValue = 999999;
                warningValueSpinEdit.Properties.AllowNullInput = DevExpress.Utils.DefaultBoolean.True;
                warningValueSpinEdit.EditValue = null; // 默认为空
                
                // 使用textEdit4作为预警值控件
                if (textEdit4 != null)
                {
                    warningValueSpinEdit.Location = textEdit4.Location;
                    warningValueSpinEdit.Size = textEdit4.Size;
                    
                    // 替换原有的预警值文本框
                    this.Controls.Remove(textEdit4);
                    this.Controls.Add(warningValueSpinEdit);
                }
                else
                {
                    // 如果找不到控件，使用默认位置
                    // 找到合适的标签
                    LabelControl warningLabel = this.Controls.OfType<LabelControl>().FirstOrDefault(l => l.Text.Contains("预警值"));
                    if (warningLabel != null)
                    {
                        warningValueSpinEdit.Location = new Point(warningLabel.Location.X + 100, warningLabel.Location.Y);
                        warningValueSpinEdit.Size = new Size(200, 20);
                        this.Controls.Add(warningValueSpinEdit);
                    }
                }

                // 2. 初始化单位下拉框
                comboBox1.Items.Clear();
                comboBox1.DropDownStyle = ComboBoxStyle.DropDownList; // 设置为下拉列表样式
                // 单位项会在InitializeUnits方法中添加

                // 3. 初始化群组类型下拉框
                comboBox3.Items.Clear();
                comboBox3.DropDownStyle = ComboBoxStyle.DropDownList; // 设置为下拉列表样式
                comboBox3.Items.AddRange(new string[] { "原材料", "半成品", "成品", "其他" });

                // 4. 初始化群组下拉框
                comboBox2.DropDownStyle = ComboBoxStyle.DropDownList; // 设置为下拉列表样式

                // 5. 初始化工艺路线下拉框和标签
                // 使用comboBox2作为参考控件
                Control referenceControl = comboBox2;
                int yOffset = 40;

                // 创建工艺路线标签
                LabelControl processRouteLabel = new LabelControl();
                processRouteLabel.Name = "processRouteLabel";
                processRouteLabel.Text = "工艺路线:";
                
                // 获取标签对应的位置
                int labelX = 20; // 默认值
                if (this.Controls.OfType<LabelControl>().Any(l => l.Text.Contains("群组:")))
                {
                    var groupLabel = this.Controls.OfType<LabelControl>().First(l => l.Text.Contains("群组:"));
                    labelX = groupLabel.Location.X;
                }
                
                int labelY = referenceControl.Location.Y + yOffset;
                processRouteLabel.Location = new Point(labelX, labelY);
                processRouteLabel.AutoSize = true;
                processRouteLabel.Visible = false; // 默认隐藏

                // 创建工艺路线下拉框
                ComboBoxEdit processRouteCombo = new ComboBoxEdit();
                processRouteCombo.Name = "processRouteCombo";
                processRouteCombo.Properties.TextEditStyle = DevExpress.XtraEditors.Controls.TextEditStyles.DisableTextEditor;
                int comboX = referenceControl.Location.X;
                int comboY = referenceControl.Location.Y + yOffset;
                processRouteCombo.Location = new Point(comboX, comboY);
                processRouteCombo.Size = referenceControl.Size;
                processRouteCombo.Visible = false; // 默认隐藏

                // 添加到表单
                this.Controls.Add(processRouteLabel);
                this.Controls.Add(processRouteCombo);
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"初始化控件异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 初始化单位数据
        /// </summary>
        private void InitializeUnits()
        {
            try
            {
                // 清空并重新初始化单位列表
                units.Clear();
                
                // 添加默认单位
                units.AddRange(new string[] { "毫米", "厘米", "米", "克", "千克", "个", "次数", "小时" });
                
                // 将单位添加到下拉框
                if (units.Count > 0)
                {
                    comboBox1.Items.AddRange(units.ToArray());
                    // 不自动选择第一项，让用户手动选择
                }
                else
                {
                    // 如果没有单位数据，添加一个默认选项
                    comboBox1.Items.Add("个");
                }
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"初始化单位数据异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                
                // 确保即使出错也有默认单位
                if (comboBox1.Items.Count == 0)
                {
                    comboBox1.Items.Add("个");
                }
            }
        }

        /// <summary>
        /// 初始化无人机相关群组数据
        /// </summary>
        private void InitializeDroneGroups()
        {
            try
            {
                // 清空并重新初始化字典
                droneGroups.Clear();

                // 原材料群组
                droneGroups["原材料"] = new List<string> {
                    "机身材料", "电子元件", "传感器", "电池组件", "螺旋桨", "摄像头组件"
                };

                // 半成品群组
                droneGroups["半成品"] = new List<string> {
                    "飞控系统", "动力系统", "通信模块", "图传系统", "云台组件", "机身材料"
                };

                // 成品群组
                droneGroups["成品"] = new List<string> {
                    "航拍无人机", "农业植保无人机", "巡检无人机", "测绘无人机", "物流运输无人机"
                };

                // 其他群组
                droneGroups["其他"] = new List<string> {
                    "包装材料", "配件", "工具", "维修组件"
                };

                // 确保字典中包含了"图传系统"这个群组
                if (!droneGroups.Values.Any(list => list.Contains("图传系统")))
                {
                    if (droneGroups.ContainsKey("半成品"))
                    {
                        droneGroups["半成品"].Add("图传系统");
                    }
                    else
                    {
                        droneGroups["半成品"] = new List<string> { "图传系统" };
                    }
                }
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"初始化群组数据异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                
                // 确保即使出错也有基本群组
                if (!droneGroups.ContainsKey("原材料"))
                    droneGroups["原材料"] = new List<string> { "默认原材料" };
                if (!droneGroups.ContainsKey("半成品"))
                    droneGroups["半成品"] = new List<string> { "默认半成品" };
                if (!droneGroups.ContainsKey("成品"))
                    droneGroups["成品"] = new List<string> { "默认成品" };
                if (!droneGroups.ContainsKey("其他"))
                    droneGroups["其他"] = new List<string> { "默认其他" };
            }
        }

        /// <summary>
        /// 初始化工艺路线数据
        /// </summary>
        private void InitializeProcessRoutes()
        {
            try
            {
                // 清空并重新初始化列表
                processRoutes.Clear();
                
                // 添加默认工艺路线
                processRoutes.AddRange(new string[] {
                    "无人机组装主线", "电子系统集成线", "机身组装线", "测试校准线",
                    "飞控调试线", "云台组装线", "质检包装线", "电池组装线"
                });
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"初始化工艺路线数据异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                
                // 确保即使出错也有默认工艺路线
                if (processRoutes.Count == 0)
                {
                    processRoutes.Add("默认工艺路线");
                }
            }
        }

        /// <summary>
        /// 生成自动递增的产品编码
        /// </summary>
        private void GenerateAutoIncrementCode()
        {
            try
            {
                // 生成当前日期部分 格式：yyMMdd
                string today = DateTime.Now.ToString(dateFormat);
                
                // 读取序号文件，获取当前最大序号
                int currentSequence = 1; // 默认从1开始
                string lastDate = string.Empty;
                
                if (File.Exists(sequenceFilePath))
                {
                    string[] fileContent = File.ReadAllLines(sequenceFilePath);
                    if (fileContent.Length >= 2)
                    {
                        lastDate = fileContent[0]; // 第一行存储日期
                        int.TryParse(fileContent[1], out currentSequence); // 第二行存储序号
                        
                        // 如果是新的一天，重置序号为1
                        if (lastDate != today)
                        {
                            currentSequence = 1;
                        }
                        // 注意：此处不自增序号，只显示当前序号
                    }
                }
                
                // 格式化为4位数字，前面补0
                string serialPart = currentSequence.ToString().PadLeft(4, '0');
                
                // 组合最终的编码：CP + 日期 + 4位序号
                string finalCode = "CP" + today + serialPart;
                
                // 设置到文本框
                textEdit1.Text = finalCode;
                
                Console.WriteLine($"生成产品编码: {finalCode}, 序号: {currentSequence}");
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"生成产品编码时发生错误：{ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                // 生成失败时使用默认编码
                textEdit1.Text = "CP" + DateTime.Now.ToString(dateFormat) + "0001";
            }
        }
        
        /// <summary>
        /// 保存成功后更新序号
        /// </summary>
        private void UpdateSequenceAfterSuccess()
        {
            // 只有在新增模式下成功保存后才更新序号
            if (isEditMode)
                return;
                
            try
            {
                // 获取当前日期
                string today = DateTime.Now.ToString(dateFormat);
                int currentSequence = 1;
                
                // 读取当前序号
                if (File.Exists(sequenceFilePath))
                {
                    string[] fileContent = File.ReadAllLines(sequenceFilePath);
                    if (fileContent.Length >= 2)
                    {
                        string lastDate = fileContent[0];
                        int.TryParse(fileContent[1], out currentSequence);
                        
                        // 如果是新的一天，重置序号为1
                        if (lastDate != today)
                        {
                            currentSequence = 1;
                        }
                        else
                        {
                            // 否则序号加1
                            currentSequence++;
                        }
                    }
                }
                
                // 保存更新后的序号到文件
                using (StreamWriter writer = new StreamWriter(sequenceFilePath, false))
                {
                    writer.WriteLine(today);
                    writer.WriteLine(currentSequence.ToString());
                }
                
                Console.WriteLine($"更新序号成功: 日期={today}, 新序号={currentSequence}");
            }
            catch (Exception ex)
            {
                // 更新序号失败不影响主流程，可以静默处理
                Console.WriteLine($"更新序号失败：{ex.Message}");
            }
        }

        /// <summary>
        /// 获取群组类型的文字描述
        /// </summary>
        private string GetProductTypeText(int typeIndex)
        {
            switch (typeIndex)
            {
                case 0: return "原材料";
                case 1: return "半成品";
                case 2: return "成品";
                case 3: return "其他";
                default: return "-";
            }
        }

        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void button2_Click(object sender, EventArgs e)
        {
            try
            {
                // 表单验证
                if (string.IsNullOrEmpty(textEdit1.Text.Trim()))
                {
                    XtraMessageBox.Show("产品编码不能为空", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    textEdit1.Focus();
                    return;
                }

                if (string.IsNullOrEmpty(textEdit2.Text.Trim()))
                {
                    XtraMessageBox.Show("产品名称不能为空", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    textEdit2.Focus();
                    return;
                }

                // 获取预警值
                SpinEdit warningValueSpinEdit = this.Controls.Find("warningValueSpinEdit", true).FirstOrDefault() as SpinEdit;
                double warningValue = 0;
                if (warningValueSpinEdit != null && warningValueSpinEdit.EditValue != null)
                {
                    if (!double.TryParse(warningValueSpinEdit.EditValue.ToString(), out warningValue))
                    {
                        XtraMessageBox.Show("预警值格式不正确，请输入有效的数字", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        warningValueSpinEdit.Focus();
                        return;
                    }
                }

                // 获取工艺路线
                string processRoute = string.Empty;
                ComboBoxEdit processRouteCombo = this.Controls.Find("processRouteCombo", true).FirstOrDefault() as ComboBoxEdit;
                if (processRouteCombo != null && processRouteCombo.Visible)
                {
                    processRoute = processRouteCombo.Text;
                }

                // 获取规格型号
                string specification = string.Empty;
                if (textEdit3 != null) // 直接使用textEdit3控件，而不是通过Controls查找
                {
                    specification = textEdit3.Text.Trim();
                }

                // 获取描述信息
                string description = string.Empty;
                if (this.Controls["memoEdit1"] is MemoEdit descEdit)
                {
                    description = descEdit.Text.Trim();
                }

                // 创建产品数据对象
                // 获取群组类型索引和文字描述
                int typeIndex = comboBox3.SelectedIndex;
                int typeValue = typeIndex + 1; // 数据库中存储的值是1-4
                string typeText = GetProductTypeText(typeIndex);
                
                Console.WriteLine($"保存产品信息: 群组类型索引={typeIndex}, 群组类型值={typeValue}, 群组类型文本={typeText}");
                
                ProductItemModel product = new ProductItemModel
                {
                    Productitemcode = textEdit1.Text.Trim(),
                    Productitemname = textEdit2.Text.Trim(),
                    // 确保规格型号不为空，如果为空则使用"-"占位
                    Productitemspecification = string.IsNullOrEmpty(specification) ? "-" : specification,
                    // 确保单位不为空
                    Productitemunit = comboBox1.SelectedItem?.ToString() ?? "-",
                    Productitemwarningvalue = warningValue,
                    // 确保工艺路线不为空
                    Processrouteid = string.IsNullOrEmpty(processRoute) ? "-" : processRoute,
                    // 确保群组不为空
                    Materialgroupid = comboBox2.SelectedItem?.ToString() ?? "-",
                    // 设置群组类型的数值（1-4）
                    Producttype = typeValue,
                    // 确保描述不为空
                    Productitemdescribe = string.IsNullOrEmpty(description) ? "-" : description,
                    // 确保产品属性不为空，这个字段是必需的
                    Productattributes = typeText, // 保存群组类型的文字描述，确保字段不为空
                    UpdatedBy = "Admin", // 这里可以替换为实际的用户名
                    UpdatedTime = DateTime.Now
                };

                // 根据模式处理Id和创建信息
                if (isEditMode && originalProduct != null)
                {
                    // 编辑模式：保留原始ID和创建信息
                    product.Id = originalProduct.Id;
                    product.CreatedBy = originalProduct.CreatedBy;
                    product.CreatedTime = originalProduct.CreatedTime;
                }
                else
                {
                    // 新增模式：设置创建信息
                    product.Id = 0;
                    product.CreatedBy = "Admin"; // 这里可以替换为实际的用户名
                    product.CreatedTime = DateTime.Now;
                }

                // 序列化为JSON
                string jsonData = Newtonsoft.Json.JsonConvert.SerializeObject(product);

                // 使用统一的API路径
                string url = "api/ProductItem/AddProductItem";
                Console.WriteLine($"请求API: {url}, 模式: {(isEditMode ? "修改" : "新增")}");
                Console.WriteLine($"请求数据: {jsonData}");

                // 临时保存原始BaseUrl
                string originalBaseUrl = Properties.Settings.Default.BaseUrl;
                string result = string.Empty;
                
                try
                {
                    // 临时修改BaseUrl为与chanpin.cs中相同的API地址
                    Properties.Settings.Default.BaseUrl = "http://47.110.243.157:5052/";
                    
                    // 发送请求
                    result = await HttpClientHelper.RequestUrl(RequestType.Post, url, jsonData);
                }
                finally
                {
                    // 恢复原始BaseUrl
                    Properties.Settings.Default.BaseUrl = originalBaseUrl;
                }
                Console.WriteLine($"API返回结果: {result}");

                if (string.IsNullOrEmpty(result))
                {
                    XtraMessageBox.Show(isEditMode ? "修改失败，服务器无响应" : "添加失败，服务器无响应", 
                        "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                try
                {
                    // 检查返回结果是否包含成功信息
                    bool isSuccess = true;
                    
                    try
                    {
                        // 解析响应
                        dynamic jsonResponse = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(result);
                        
                        if (jsonResponse != null && 
                            ((jsonResponse.code != null && jsonResponse.code.ToString() != "200") || 
                             (jsonResponse.Code != null && jsonResponse.Code.ToString() != "200")))
                        {
                            isSuccess = false;
                            string message = jsonResponse.message ?? jsonResponse.Message ?? "未知错误";
                            XtraMessageBox.Show($"操作失败：{message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                    catch (Exception parseEx)
                    {
                        // 解析失败，记录异常但仍然继续（可能API返回非标准格式）
                        Console.WriteLine($"解析API返回结果异常: {parseEx.Message}");
                        
                        // 尝试使用JObject解析
                        try
                        {
                            Newtonsoft.Json.Linq.JObject jsonObj = Newtonsoft.Json.Linq.JObject.Parse(result);
                            if (jsonObj["Code"]?.ToString() != "200")
                            {
                                isSuccess = false;
                                string errorMsg = jsonObj["Message"]?.ToString() ?? (isEditMode ? "修改失败" : "添加失败");
                                XtraMessageBox.Show(errorMsg, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            }
                        }
                        catch
                        {
                            // 如果两种方式都解析失败，则视为失败
                            isSuccess = false;
                            XtraMessageBox.Show("解析返回数据失败", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                    }
                    
                    if (isSuccess)
                    {
                        // 保存成功后更新序号（仅在新增模式下）
                        if (!isEditMode)
                        {
                            Console.WriteLine("保存成功，开始更新序号");
                            UpdateSequenceAfterSuccess();
                        }
                        
                        XtraMessageBox.Show(isEditMode ? "修改成功" : "添加成功", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        // 设置对话框结果为OK并关闭窗体
                        this.DialogResult = DialogResult.OK;
                        this.Close();
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"处理API返回结果异常: {ex.Message}\n{ex.StackTrace}");
                    XtraMessageBox.Show($"解析返回数据异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"保存异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// 取消
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            // 设置对话框结果为Cancel
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }

        /// <summary>
        /// 单位
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            // 单位选择逻辑（如果需要）
        }

        /// <summary>
        /// 群组类型
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void comboBox3_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                // 保存当前选中的群组值，以便稍后恢复
                string currentSelectedGroup = comboBox2.SelectedItem?.ToString();
                
                // 清空群组下拉框
                comboBox2.Items.Clear();
                comboBox2.Text = "";

                // 获取选择的群组类型
                string selectedType = comboBox3.SelectedItem?.ToString();
                if (!string.IsNullOrEmpty(selectedType))
                {
                    Console.WriteLine($"选中的群组类型: {selectedType}");
                    
                    // 确保选择的类型在字典中存在
                    if (!droneGroups.ContainsKey(selectedType))
                    {
                        droneGroups[selectedType] = new List<string> { $"默认{selectedType}" };
                        Console.WriteLine($"添加默认群组: 默认{selectedType}");
                    }
                    
                    // 确保该类型有至少一个群组
                    if (droneGroups[selectedType].Count == 0)
                    {
                        droneGroups[selectedType].Add($"默认{selectedType}");
                        Console.WriteLine($"添加默认群组: 默认{selectedType}");
                    }
                    
                    // 添加对应的群组选项
                    comboBox2.Items.AddRange(droneGroups[selectedType].ToArray());
                    
                    // 尝试保持之前选择的群组（如果在新类型中存在）
                    if (!string.IsNullOrEmpty(currentSelectedGroup))
                    {
                        int previousIndex = comboBox2.Items.IndexOf(currentSelectedGroup);
                        if (previousIndex >= 0)
                        {
                            comboBox2.SelectedIndex = previousIndex;
                            Console.WriteLine($"恢复之前选择的群组: {currentSelectedGroup}");
                        }
                        else if (comboBox2.Items.Count > 0)
                        {
                            comboBox2.SelectedIndex = 0;
                            Console.WriteLine($"无法恢复之前的群组，选择第一个: {comboBox2.Items[0]}");
                        }
                    }
                    else if (comboBox2.Items.Count > 0)
                    {
                        comboBox2.SelectedIndex = 0;
                        Console.WriteLine($"选择第一个群组: {comboBox2.Items[0]}");
                    }
                }

                // 根据群组类型决定是否显示工艺路线
                bool showProcessRoute = selectedType == "半成品" || selectedType == "成品";
                Console.WriteLine($"是否显示工艺路线: {showProcessRoute}");

                // 获取工艺路线控件
                LabelControl processRouteLabel = this.Controls.Find("processRouteLabel", true).FirstOrDefault() as LabelControl;
                ComboBoxEdit processRouteCombo = this.Controls.Find("processRouteCombo", true).FirstOrDefault() as ComboBoxEdit;

                if (processRouteLabel != null)
                    processRouteLabel.Visible = showProcessRoute;

                if (processRouteCombo != null)
                {
                    // 保存当前选择的工艺路线
                    string currentRoute = processRouteCombo.Text;
                    
                    processRouteCombo.Visible = showProcessRoute;
                    processRouteCombo.Properties.Items.Clear();
                    processRouteCombo.Text = "";

                    // 如果需要显示工艺路线，则填充数据
                    if (showProcessRoute)
                    {
                        // 确保工艺路线列表不为空
                        if (processRoutes.Count == 0)
                        {
                            processRoutes.Add("默认工艺路线");
                            Console.WriteLine("添加默认工艺路线");
                        }
                        
                        processRouteCombo.Properties.Items.AddRange(processRoutes.ToArray());
                        
                        // 尝试恢复之前选择的工艺路线
                        if (!string.IsNullOrEmpty(currentRoute))
                        {
                            int previousRouteIndex = -1;
                            for (int i = 0; i < processRouteCombo.Properties.Items.Count; i++)
                            {
                                if (processRouteCombo.Properties.Items[i].ToString() == currentRoute)
                                {
                                    previousRouteIndex = i;
                                    break;
                                }
                            }
                            
                            if (previousRouteIndex >= 0)
                            {
                                processRouteCombo.SelectedIndex = previousRouteIndex;
                                Console.WriteLine($"恢复之前选择的工艺路线: {currentRoute}");
                            }
                            else if (processRouteCombo.Properties.Items.Count > 0)
                            {
                                processRouteCombo.SelectedIndex = 0;
                                Console.WriteLine($"无法恢复之前的工艺路线，选择第一个: {processRouteCombo.Properties.Items[0]}");
                            }
                        }
                        else if (processRouteCombo.Properties.Items.Count > 0)
                        {
                            processRouteCombo.SelectedIndex = 0;
                            Console.WriteLine($"选择第一个工艺路线: {processRouteCombo.Properties.Items[0]}");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                XtraMessageBox.Show($"群组类型选择异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Console.WriteLine($"群组类型选择异常: {ex.Message}\n{ex.StackTrace}");
                
                // 确保即使出错也有基本选项
                if (comboBox2.Items.Count == 0)
                {
                    comboBox2.Items.Add("默认群组");
                    comboBox2.SelectedIndex = 0;
                    Console.WriteLine("添加默认群组选项");
                }
            }
        }

        /// <summary>
        /// 群组
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void comboBox2_SelectedIndexChanged(object sender, EventArgs e)
        {
            // 群组选择逻辑（如果需要）
        }
    }
}